package com.malou.client.ventas.separacion;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.extjs.gxt.ui.client.Style.HorizontalAlignment;
import com.extjs.gxt.ui.client.data.BaseListLoader;
import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.data.BeanModelFactory;
import com.extjs.gxt.ui.client.data.BeanModelLookup;
import com.extjs.gxt.ui.client.data.BeanModelReader;
import com.extjs.gxt.ui.client.data.ListLoadResult;
import com.extjs.gxt.ui.client.data.ListLoader;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.KeyListener;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.store.StoreEvent;
import com.extjs.gxt.ui.client.store.StoreListener;
import com.extjs.gxt.ui.client.util.IconHelper;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Dialog;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.Status;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.form.DateField;
import com.extjs.gxt.ui.client.widget.form.Field;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.FormPanel;
import com.extjs.gxt.ui.client.widget.form.HiddenField;
import com.extjs.gxt.ui.client.widget.form.NumberField;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.form.Validator;
import com.extjs.gxt.ui.client.widget.grid.AggregationRenderer;
import com.extjs.gxt.ui.client.widget.grid.AggregationRowConfig;
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
import com.extjs.gxt.ui.client.widget.grid.Grid;
import com.extjs.gxt.ui.client.widget.grid.RowNumberer;
import com.extjs.gxt.ui.client.widget.grid.SummaryType;
import com.extjs.gxt.ui.client.widget.layout.ColumnData;
import com.extjs.gxt.ui.client.widget.layout.ColumnLayout;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.extjs.gxt.ui.client.widget.layout.FormLayout;
import com.extjs.gxt.ui.client.widget.toolbar.FillToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.i18n.client.DateTimeFormat;
import com.google.gwt.i18n.client.NumberFormat;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.malou.client.MalouConstants;
import com.malou.client.util.Utilities;
import com.malou.client.ventas.cliente.Clientes;
import com.malou.client.ventas.modeloprenda.ModeloPrenda;
import com.malou.client.ventas.modeloprenda.ModeloPrendaService;
import com.malou.client.ventas.modeloprenda.ModeloPrendaServiceAsync;
import com.malou.client.ventas.modeloprenda.ModeloPrendas;
import com.malou.client.ventas.serie.Series;

public class SeparacionDialog extends Dialog {
	public NumberField dni_ruc;
	public HiddenField<String> cliente_id;
	public TextField<String> nombres;	
	private ComboBox<BeanModel> documento;
	private Button guardar;
	private Button cancelar;
	public Status status;
	private MalouConstants constants = GWT.create(MalouConstants.class);
	
	public TextField<String> codigo;	
	public HiddenField<String> prenda_id;
	public ComboBox<BeanModel> prenda;
	public NumberField preciounitario;
	public NumberField acuenta;
	private NumberField cantidad;
	public NumberField stock;
	private Button addDetalle;
	private Button delDetalle;
	
	AggregationRowConfig<BeanModel> total;	
	AggregationRowConfig<BeanModel> subtotal;
	AggregationRowConfig<BeanModel> igv;
	
	private Double igv_value = 1.00;
	private ListStore<BeanModel> store;
	private EditorGrid<BeanModel> grid;
	private ToolBar toolBar;
	private ToolBar aCuentaBar;
	private DateField fechavencimiento;
	
	private ComboBox<BeanModel> tipo;
	private ComboBox<BeanModel> tela;
	private ComboBox<BeanModel> talla;
	private ComboBox<BeanModel> color;
	
	public SeparacionDialog(){
		setLayout(new FitLayout());
		setModal(true);
		setPlain(true);
		setSize(980, 505);
		setClosable(true);
		
		FormPanel panel = new FormPanel();		
		panel.setBorders(false);
	    panel.setBodyBorder(false);
	    panel.setPadding(5);
	    panel.setHeaderVisible(false);
	    
	    addFields(panel);
	    
	    setButtonAlign(HorizontalAlignment.LEFT);
	    setButtons("");
	    add(panel);
	    
	    setBodyBorder(true);	    
	    setResizable(false);	    
	    setFocusWidget(dni_ruc);
	    
	    setIconStyle("icon-stock");
		setHeading(constants.separacionNuevo());
	}
	private void addFields(ContentPanel cp) {
		
		LayoutContainer main = new LayoutContainer();		
		
		LayoutContainer headLeft = new LayoutContainer();
		headLeft.setStyleAttribute("paddingLeft", "470px"); 
		headLeft.setLayout(new ColumnLayout());
		
	    LayoutContainer head_data = new LayoutContainer();
	    head_data.setLayout(new ColumnLayout());
	    
	    FieldSet cliente_data = new FieldSet();
	    cliente_data.setHeading(constants.separacionClienteData());
	    cliente_data.setStyleAttribute("padding", "10px"); 
	    cliente_data.setLayout(new ColumnLayout());
	    
	    head_data.add(cliente_data, new ColumnData(.51));
	    
	    FieldSet documento_data = new FieldSet();
	    documento_data.setHeading(constants.separacionTipoSeparacion());
	    documento_data.setStyleAttribute("padding", "10px");
	    documento_data.setStyleAttribute("paddingRight", "8px");
	    documento_data.setStyleAttribute("marginLeft", "10px");
	    
	    documento_data.setLayout(new ColumnLayout());
	    
	    LayoutContainer lfechavencimiento = new LayoutContainer();
	    FormLayout layout =new FormLayout();
		layout.setLabelWidth(110);
		lfechavencimiento.setLayout(layout);
		
		fechavencimiento = new DateField();	    
		fechavencimiento.setFieldLabel(constants.separacionFechaVencimiento());	
		fechavencimiento.getPropertyEditor().setFormat(DateTimeFormat.getFormat("yyyy-MM-dd"));
		fechavencimiento.setAllowBlank(false);
	    fechavencimiento.setValue(new Date());
	    lfechavencimiento.add(fechavencimiento, new FormData(100,22));
	    
		documento_data.add(lfechavencimiento, new ColumnData(.53));
		
		LayoutContainer ldocumento = new LayoutContainer();
	    layout =new FormLayout();
		layout.setLabelWidth(100);
		ldocumento.setLayout(layout);
	    
	    Series.getComboDocumento();
	    Series.loaderCombo.load(); // for edit
	    
	    documento = new ComboBox<BeanModel>();  
	    documento.setEditable(false);
	    documento.setFieldLabel(constants.separacionDocumentoSeparacion());
	    
	    
	    documento.setDisplayField("descripcion");
	    documento.setEmptyText(constants.seleccione());	 	    
	    documento.setStore(Series.storeCombo);  
	    documento.setTypeAhead(true);  
	    documento.setTriggerAction(TriggerAction.ALL);
	    documento.setValueField("descripcion");
	    
	    documento.getStore().addStoreListener(new StoreListener<BeanModel>(){
	    	public void storeDataChanged(StoreEvent<BeanModel> se){
	    		super.storeDataChanged(se);
	    		List<BeanModel> list = new ArrayList<BeanModel>();
	    		list.add(documento.getStore().getAt(2));//documento: otro
	    		documento.setSelection(list);
	    	}
	    });
	    
	    documento.addSelectionChangedListener(new SelectionChangedListener<BeanModel>() {
			
			@Override
			public void selectionChanged(SelectionChangedEvent<BeanModel> se) {
				//id: 2 => factura
				if(se.getSelectedItem().get("id").toString().equals("2")){
					igv_value = Utilities.igv_value;					
				}else{
					igv_value = 1.00;
				}
			grid.getView().refresh(false);
				
			}
		});
	    ldocumento.add(documento, new FormData(100, 22));
	    documento_data.add(ldocumento, new ColumnData(.47));
	    
	    head_data.add(documento_data, new ColumnData(.48));
	    
	    LayoutContainer ldni_ruc = new LayoutContainer();
	    layout =new FormLayout();
		layout.setLabelWidth(60);
	    ldni_ruc.setLayout(layout);
	    
		LayoutContainer lnombres = new LayoutContainer();
		layout =new FormLayout();
		layout.setLabelWidth(55);
		
		lnombres.setLayout(layout);
		lnombres.setStyleAttribute("paddingLeft", "10px");
		
		cliente_id = new HiddenField<String>();
		ldni_ruc.add(cliente_id);
		
		dni_ruc = new NumberField();
		dni_ruc.setFieldLabel("DNI / RUC");		
		dni_ruc.setAllowDecimals(false);
		dni_ruc.setAllowBlank(false);
		dni_ruc.setPropertyEditorType(Long.class);
		dni_ruc.setMinLength(8);
		dni_ruc.setMaxLength(11);		
		Clientes.separacionDialog = this;
		dni_ruc.addKeyListener(new KeyListener(){
			public void componentKeyDown(ComponentEvent event){
				if(event.getKeyCode() == KeyCodes.KEY_ENTER){	
					if(Utilities.hasValue(dni_ruc)){
						Clientes.getClienteSeparacion(dni_ruc.getValue().toString());
					}					
					prenda.focus();
				}
			}
		});
		
		ldni_ruc.add(dni_ruc, new FormData(100, 20));
		
		dni_ruc.setData("realizoseparacion", false);
		final String sMsg = constants.clienteSeparacionPendiente();
		dni_ruc.setValidator(new Validator() {			
			@Override
			public String validate(Field<?> field, String value) {
				if(Boolean.parseBoolean(field.getData("realizoseparacion").toString()))
					return sMsg;
				return null;
			}
		});
		
		nombres = new TextField<String>();
		nombres.setEnabled(false);
		nombres.setFieldLabel(constants.separacionNombresData());
		lnombres.add(nombres, new FormData(200, 20));
		
	    cliente_data.add(ldni_ruc, new ColumnData(.4));
	    cliente_data.add(lnombres, new ColumnData(.6));
	    	    
	    FieldSet prenda_data = new FieldSet();
	    prenda_data.setHeading(constants.separacionAgregarDetalle());
	    prenda_data.setStyleAttribute("marginTop", "10px");
	    prenda_data.setLayout(new ColumnLayout());
	    
	    LayoutContainer lcodigo = new LayoutContainer();
	    layout =new FormLayout();
		layout.setLabelWidth(45);
		lcodigo.setLayout(layout);
		
		prenda_id = new HiddenField<String>();
		lcodigo.add(prenda_id);
		
		ModeloPrendas.separacionDialog = this;
		codigo = new TextField<String>();
		codigo.setFieldLabel(constants.separacionCodigo());		
		
		codigo.addKeyListener(new KeyListener(){
			
			public void componentKeyDown(ComponentEvent event){
				if(event.getKeyCode() == KeyCodes.KEY_ENTER){
					if(codigo.getValue() != null){
						ModeloPrendas.getPrendaSeparacion(codigo.getValue());						
					}
				}				
			}
		});
		codigo.setVisible(false);
		lcodigo.add(codigo, new FormData(50,22));
		
		prenda_data.add(lcodigo, new ColumnData(.13));
		
		LayoutContainer lprenda = new LayoutContainer();
		lprenda.setStyleAttribute("paddingLeft", "10px");
	    layout =new FormLayout();
		layout.setLabelWidth(70);
		lprenda.setLayout(layout);
		
		ModeloPrendas.getComboTipoPrendas();
		ModeloPrendas.loaderTipoPrenda.load();
	    
	    tipo = new ComboBox<BeanModel>();  
	    tipo.setEditable(false);
		tipo.setFieldLabel(constants.modeloPrendaTipo());
		tipo.setDisplayField("nombre");
		tipo.setEmptyText("Seleccione...");
		tipo.setWidth(150);  
		tipo.setStore(ModeloPrendas.storeTipoPrenda);  
		tipo.setTypeAhead(true);  
		tipo.setTriggerAction(TriggerAction.ALL);
		tipo.setValueField("nombre");		
		tipo.setUseQueryCache(false);		
		lprenda.add(tipo, new FormData(145, 22));
		
		tipo.addSelectionChangedListener(new SelectionChangedListener<BeanModel>() {
			
			@Override
			public void selectionChanged(SelectionChangedEvent<BeanModel> se) {				
				prenda.clear();
			}
		});
		
		tipo.addKeyListener(new KeyListener(){
			public void componentKeyDown(ComponentEvent event){
				if(event.getKeyCode() == KeyCodes.KEY_ENTER){					
					tela.focus();
				}
			}
		});
		
		
		//ModeloPrendas.autoComplete();
		final ModeloPrendaServiceAsync mps = GWT.create(ModeloPrendaService.class);
		RpcProxy<List<ModeloPrenda>> proxy = new RpcProxy<List<ModeloPrenda>>() {
			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<List<ModeloPrenda>> callback) {
				Integer tipo_id = (tipo.getValue() != null) ? (Integer)tipo.getValue().get("id"): null;
				Integer tela_id = (tela.getValue() != null) ? (Integer)tela.getValue().get("id"): null;
				Integer talla_id = (talla.getValue() != null) ? (Integer)talla.getValue().get("id"): null;
				Integer color_id = (color.getValue() != null) ? (Integer)color.getValue().get("id"): null;
				mps.listModeloPrenda(tipo_id,tela_id,talla_id,color_id, callback);  				
			}	      
	    };	
	    ListLoader<ListLoadResult<ModelData>> loaderAutocomplete = new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());	      
            
	    ListStore<BeanModel> storeAutocomplete = new ListStore<BeanModel>(loaderAutocomplete);
		
		
		prenda = new ComboBox<BeanModel>();
		prenda.setFieldLabel(constants.separacionPrenda());		
		prenda.setDisplayField("nombre");			 	    
		prenda.setStore(storeAutocomplete);		
		prenda.setValueField("nombre");
		prenda.setEditable(false);
		prenda.setUseQueryCache(false);
		prenda.setTriggerAction(TriggerAction.ALL);
		//prenda.setHideTrigger(true);  
		//prenda.setPageSize(10);
		
		prenda.addSelectionChangedListener(new SelectionChangedListener<BeanModel>() {
			
			@Override
			public void selectionChanged(SelectionChangedEvent<BeanModel> se) {
				if(se.getSelectedItem() != null){
				codigo.setValue(se.getSelectedItem().get("codigo").toString());
				prenda_id.setValue(se.getSelectedItem().get("id").toString());
				preciounitario.setValue(Double.valueOf(se.getSelectedItem().get("precioventa").toString()));
				stock.setValue(Integer.valueOf(se.getSelectedItem().get("stock").toString()));
				}
			}
		});
		
		prenda.addKeyListener(new KeyListener(){
			public void componentKeyDown(ComponentEvent event){
				if(event.getKeyCode() == KeyCodes.KEY_ENTER){					
					preciounitario.focus();
				}
			}
		});
		
		lprenda.add(prenda, new FormData(145, 22));
		
		prenda_data.add(lprenda, new ColumnData(.28));
		
		LayoutContainer lpreciounitario = new LayoutContainer();
		lpreciounitario.setStyleAttribute("paddingLeft", "10px");
	    layout =new FormLayout();
		layout.setLabelWidth(85);
		lpreciounitario.setLayout(layout);
		
		ModeloPrendas.getComboTelas();
		ModeloPrendas.loaderTela.load();
	    
	    tela = new ComboBox<BeanModel>();  
	    tela.setEditable(false);
	    tela.setFieldLabel(constants.modeloPrendaTela());
	    tela.setDisplayField("descripcion");
	    tela.setEmptyText("Seleccione...");
	    tela.setWidth(150);  
	    tela.setStore(ModeloPrendas.storeTela);  
	    tela.setTypeAhead(true);  
	    tela.setTriggerAction(TriggerAction.ALL);
	    tela.setValueField("descripcion");	    
	    tela.setUseQueryCache(false);
	    lpreciounitario.add(tela,new FormData(98, 22));
	    
	    tela.addSelectionChangedListener(new SelectionChangedListener<BeanModel>() {
			
			@Override
			public void selectionChanged(SelectionChangedEvent<BeanModel> se) {				
				prenda.clear();
			}
		});
	    
	    tela.addKeyListener(new KeyListener(){
			public void componentKeyDown(ComponentEvent event){
				if(event.getKeyCode() == KeyCodes.KEY_ENTER){					
					talla.focus();
				}
			}
		});
		
		preciounitario = new NumberField();
		preciounitario.setFieldLabel(constants.separacionPrecio());		
		preciounitario.setAllowNegative(false);		
		preciounitario.setFormat(NumberFormat.getFormat("0.00"));
		preciounitario.setMinValue(1.00);
		preciounitario.setSelectOnFocus(true);
		preciounitario.addKeyListener(new KeyListener(){
			
			public void componentKeyDown(ComponentEvent event){
				if(event.getKeyCode() == KeyCodes.KEY_ENTER){
					cantidad.focus();
				}				
			}
		});
		lpreciounitario.add(preciounitario,new FormData(98, 22));
		
		prenda_data.add(lpreciounitario, new ColumnData(.24));
		
		LayoutContainer lcantidad = new LayoutContainer();
		lcantidad.setStyleAttribute("paddingLeft", "10px");
	    layout =new FormLayout();
		layout.setLabelWidth(50);
		lcantidad.setLayout(layout);
		
		ModeloPrendas.getComboTallas();
		ModeloPrendas.loaderTalla.load();
	    
	    talla = new ComboBox<BeanModel>();  
	    talla.setEditable(false);
	    talla.setFieldLabel(constants.modeloPrendaTalla());
	    talla.setDisplayField("descripcion");
	    talla.setEmptyText("Seleccione...");
	    talla.setWidth(150);  
	    talla.setStore(ModeloPrendas.storeTalla);  
	    talla.setTypeAhead(true);  
	    talla.setTriggerAction(TriggerAction.ALL);
	    talla.setValueField("descripcion");	    
	    talla.setUseQueryCache(false);
	    lcantidad.add(talla,new FormData(55, 22));
	    
	    talla.addSelectionChangedListener(new SelectionChangedListener<BeanModel>() {
			
			@Override
			public void selectionChanged(SelectionChangedEvent<BeanModel> se) {				
				prenda.clear();
			}
		});
	    
	    talla.addKeyListener(new KeyListener(){
			public void componentKeyDown(ComponentEvent event){
				if(event.getKeyCode() == KeyCodes.KEY_ENTER){					
					color.focus();
				}
			}
		});
		
		cantidad = new NumberField();
		cantidad.setFieldLabel(constants.separacionCantidadData());		
		cantidad.setAllowNegative(false);
		cantidad.setAllowDecimals(false);
		cantidad.setPropertyEditorType(Integer.class);
		cantidad.setMinValue(1);
		cantidad.addKeyListener(new KeyListener(){
			
			public void componentKeyDown(ComponentEvent event){
				if(event.getKeyCode() == KeyCodes.KEY_ENTER){					
					agregarDetalle();
				}				
			}
		});
		lcantidad.add(cantidad,new FormData(55, 22));
		
		prenda_data.add(lcantidad, new ColumnData(.16));
		
		LayoutContainer lstock = new LayoutContainer();
		lstock.setStyleAttribute("paddingLeft", "10px");
	    layout =new FormLayout();
		layout.setLabelWidth(35);
		lstock.setLayout(layout);
		
		ModeloPrendas.getComboColores();
		ModeloPrendas.loaderColor.load();
	    
	    color = new ComboBox<BeanModel>();  
	    color.setEditable(false);
	    color.setFieldLabel(constants.modeloPrendaColor());
	    color.setDisplayField("descripcion");
	    color.setEmptyText("Seleccione...");
	    color.setWidth(150);  
	    color.setStore(ModeloPrendas.storeColor);  
	    color.setTypeAhead(true);  
	    color.setTriggerAction(TriggerAction.ALL);
	    color.setValueField("descripcion");	    
	    color.setUseQueryCache(false);
	    lstock.add(color, new FormData(88, 22));
	    
	    color.addSelectionChangedListener(new SelectionChangedListener<BeanModel>() {
			
			@Override
			public void selectionChanged(SelectionChangedEvent<BeanModel> se) {				
				prenda.clear();
				if(color.getValue()!= null){
					if(color.getValue().get("id")==null)
						color.clear();
				}
			}
		});
	    
	    color.addKeyListener(new KeyListener(){
			public void componentKeyDown(ComponentEvent event){
				if(event.getKeyCode() == KeyCodes.KEY_ENTER){					
					prenda.focus();
				}
			}
		});
	    
		stock = new NumberField();
		stock.setEnabled(false);
		stock.setFieldLabel("Stock");				
		stock.setPropertyEditorType(Integer.class);
		lstock.add(stock, new FormData(88, 22));
		
		prenda_data.add(lstock, new ColumnData(.16));
		
		addDetalle = new Button(constants.separacionAgregar());
		addDetalle.addSelectionListener(new SelectionListener<ButtonEvent>() {
	      public void componentSelected(ButtonEvent ce) {
	    	  agregarDetalle();	    	  
	      }
	    });
		addDetalle.setStyleAttribute("paddingLeft", "10px");
		addDetalle.setStyleAttribute("marginTop", "26px");
		prenda_data.add(addDetalle, new ColumnData(.10));
		
	    main.add(headLeft, new FormData("100%"));
	    main.add(head_data, new FormData("100%"));	    
	    main.add(prenda_data, new FormData("100%"));
	    //detalle
	    toolBar = new ToolBar();	    
	    
	    delDetalle = new Button(constants.eliminar(), IconHelper.createPath("images/icons/delete.gif"));
	    delDetalle.setEnabled(false);
        
        SelectionListener<ButtonEvent> sl_del;        
        sl_del = new SelectionListener<ButtonEvent>(){
        	
        	@Override
			public void componentSelected(ButtonEvent ce) {		
				BeanModel be =grid.getSelectionModel().getSelectedItem();
				grid.getStore().remove(be);
			}
        };
        delDetalle.addSelectionListener(sl_del);
        toolBar.add(delDetalle);
	    
	    store = new ListStore<BeanModel>();
	    store.addStoreListener(new StoreListener<BeanModel>(){
	    	public void storeUpdate(StoreEvent<BeanModel> se) {	    		
	    		Double precio = (Double) se.getRecord().get("preciounitario");
	    		Integer cantidad = (Integer) se.getRecord().get("cantidad");
	    		se.getRecord().set("subtotal", precio*cantidad);
	    		store.commitChanges();
	    	}	    	
	    });
	    
	    RowNumberer r = new RowNumberer();
	    ArrayList<ColumnConfig> columns = new ArrayList<ColumnConfig>();
	    ColumnConfig column = new ColumnConfig();
	    columns.add(r);
	    //columns.add(new ColumnConfig("codigo", constants.separacionCodigoPrenda(), 80));
	    columns.add(new ColumnConfig("tipoprenda", constants.modeloPrendaTipo(), 100));
	    columns.add(new ColumnConfig("tela", constants.modeloPrendaTela(), 90));
	    columns.add(new ColumnConfig("talla", constants.modeloPrendaTalla(), 80));
	    columns.add(new ColumnConfig("color", constants.modeloPrendaColor(), 80));
	    
		columns.add(new ColumnConfig("modeloprenda", constants.separacionModeloPrenda(), 260));
		
		column = new ColumnConfig("preciounitario", constants.separacionCosto(), 100);
        column.setAlignment(HorizontalAlignment.RIGHT);
        column.setNumberFormat(NumberFormat.getFormat("0.00"));
        
        NumberField precio = new NumberField();
        precio.setAllowBlank(false);
        precio.setPropertyEditorType(Double.class);
        precio.setAllowNegative(false);
        precio.setFormat(NumberFormat.getFormat("0.00"));
        
        column.setEditor(new CellEditor(precio));
        columns.add(column);
        
        column = new ColumnConfig("cantidad", constants.separacionCantidad(), 80);
        column.setAlignment(HorizontalAlignment.RIGHT);   
        
        NumberField cantidad = new NumberField();
        cantidad.setAllowBlank(false);
        cantidad.setPropertyEditorType(Integer.class);
        cantidad.setAllowNegative(false);
        cantidad.setAllowDecimals(false);
        
        column.setEditor(new CellEditor(cantidad));
        columns.add(column); 
                  
        column = new ColumnConfig("subtotal", constants.separacionSubtotal(), 80);
        column.setAlignment(HorizontalAlignment.RIGHT);        
        columns.add(column);
        
        ColumnModel cm = new ColumnModel(columns);
        
        subtotal = new AggregationRowConfig<BeanModel>();
        subtotal.setHtml("cantidad", constants.separacionSubtotalResumen());
        
        subtotal.setSummaryType("subtotal", SummaryType.SUM);  
        subtotal.setRenderer("subtotal", new AggregationRenderer<BeanModel>() {  
            public Object render(Number value, int colIndex, Grid<BeanModel> grid, ListStore<BeanModel> store) {  
                
            	if(value != null)
            		return NumberFormat.getFormat("0.00").format(value.doubleValue()/igv_value);
            	else
            		return "";
            }  
          });        
        
        
        
        cm.addAggregationRow(subtotal);
        
        igv = new AggregationRowConfig<BeanModel>();
        igv.setHtml("cantidad", constants.separacionIgv());
        
        igv.setSummaryType("subtotal", SummaryType.SUM); 
         
        igv.setRenderer("subtotal", new AggregationRenderer<BeanModel>() {  
            public Object render(Number value, int colIndex, Grid<BeanModel> grid, ListStore<BeanModel> store) {             
            	
            	if(value != null)
            		return NumberFormat.getFormat("0.00").format(value.doubleValue()-value.doubleValue()/igv_value);
            	else
            		return "";
            }  
          });
        cm.addAggregationRow(igv); 
        
        
        total = new AggregationRowConfig<BeanModel>();
        total.setHtml("cantidad", constants.separacionTotalResumen());
        
        total.setSummaryType("subtotal", SummaryType.SUM);
        total.setSummaryFormat("subtotal", NumberFormat.getFormat("0.00"));
        
        cm.addAggregationRow(total);        
        
        
        grid = new EditorGrid<BeanModel>(store, cm);
        grid.addPlugin(r);
        
        //grid.setAutoExpandColumn("modeloprenda");
        grid.getSelectionModel().addListener(Events.SelectionChange, new Listener<SelectionChangedEvent<BeanModel>>(){

			@Override
			public void handleEvent(SelectionChangedEvent<BeanModel> be) {				
				if(be.getSelectedItem() != null)
					delDetalle.setEnabled(true);
				else
					delDetalle.setEnabled(false);
			}
		});
        
        ContentPanel detalle = new ContentPanel();
        detalle.setHeaderVisible(false);
        detalle.setLayout(new FitLayout());
        detalle.setHeight(250);
        detalle.add(grid);
        detalle.setTopComponent(toolBar); 
        
        LayoutContainer lacuenta = new LayoutContainer();
        lacuenta.setStyleAttribute("paddingRight", "85px");
	    layout =new FormLayout();
		layout.setLabelWidth(85);
		lacuenta.setLayout(layout);
		
		aCuentaBar = new ToolBar();
		acuenta = new NumberField();
		acuenta.setFieldLabel(constants.separacionAcuenta());		
		acuenta.setAllowNegative(false);
		acuenta.setAllowBlank(false);
		acuenta.setFormat(NumberFormat.getFormat("0.00"));
		acuenta.setMinValue(1.00);
		lacuenta.add(acuenta,new FormData(58, 22));
		aCuentaBar.setAlignment(HorizontalAlignment.RIGHT);
		aCuentaBar.add(lacuenta);		
        detalle.setBottomComponent(aCuentaBar);
        
        
        main.add(detalle, new FormData("100%"));
        
	    cp.add(main);
	}
	
	@Override
	  protected void createButtons() {
	    super.createButtons();
	    
	    if (constants == null) {
	    	constants = GWT.create(MalouConstants.class);
		}
	    
	    status = new Status();
	    status.setBusy(constants.guardando());
	    status.hide();
	    status.setAutoWidth(true);
	    getButtonBar().add(status);
	    
	    getButtonBar().add(new FillToolItem());
	    
	    cancelar = new Button(constants.limpiar());
	    
	    cancelar.addSelectionListener(new SelectionListener<ButtonEvent>() {
	      public void componentSelected(ButtonEvent ce) {	    	  
	    	  clearPrincipal();
	      }

	    });

	    guardar = new Button(constants.guardar());
	    
	    guardar.addSelectionListener(new SelectionListener<ButtonEvent>() {
	      public void componentSelected(ButtonEvent ce) {
	    	  if(validarPrincipal()){	    		  
	    		  Separacion v = new Separacion();
	    		  if(cliente_id.getValue() != null)
	    			  v.setCliente_id(Integer.valueOf(cliente_id.getValue()));
	    		  if(documento.getValue().get("id") != null)
	    			  v.setTipodocumento_id(Integer.parseInt(documento.getValue().get("id").toString()));
	    		  
	    		  List<DetalleSeparacion> list = new ArrayList<DetalleSeparacion>(); 
	    		  DetalleSeparacion dv;
	    		  Double monto;
	    		  Double precio;
	    		  Integer cant;
	    		  Double total = 0.00;
	    		  for(BeanModel b:store.getModels()){
	    			  dv = new DetalleSeparacion();
	    			  dv.setModeloprenda_id(Integer.valueOf(b.get("modeloprenda_id").toString()));
	    			  dv.setModeloprenda(b.get("modeloprenda").toString());
	    			  precio = Double.valueOf(b.get("preciounitario").toString());
	    			  dv.setPreciounitario(precio);
	    			  cant = Integer.valueOf(b.get("cantidad").toString());
	    			  dv.setCantidad(cant);
	    			  monto = precio * cant;
	    			  dv.setSubtotal(monto);
	    			  list.add(dv);
	    			  
	    			  total += monto;
	    		  }	
	    		  v.setTotal(total);
	    		  v.setIgv(total*igv_value);
	    		  v.setFecha(new Date());
	    		  v.setFechavencimiento(fechavencimiento.getValue());	    		  
	    		  
	    		  PagarSeparacion pag = new PagarSeparacion();
	    		  pag.setFecha(new Date());
	    		  pag.setHora(new Date());
	    		  pag.setMonto(Double.valueOf(acuenta.getValue().toString()));
	    		  
	    		  if(pag.getMonto() < v.getTotal()){
	    			  v.setSaldo(v.getTotal()-pag.getMonto());
	    			  status.show();
		    		  getButtonBar().disable();
	    			  Separaciones.separacionDialog = SeparacionDialog.this;
	    			  Separaciones.save(v,pag, list);
	    		  }else{
	    			  MessageBox.alert(constants.sistemaMarcocruzado(), constants.separacionAcuentaTotal(), null);
	    			  acuenta.focus();
	    		  }
	    	  }	    	  
	      }
	    });
	    
	    addButton(guardar);
	    addButton(cancelar);	    
	    
	  }
	
	public boolean validarDetalle(){
		codigo.setAllowBlank(false);
		prenda.setAllowBlank(false);
		preciounitario.setAllowBlank(false);
		cantidad.setAllowBlank(false);
		
		tipo.setAllowBlank(false);
		tela.setAllowBlank(false);
		talla.setAllowBlank(false);
		
		boolean cod = codigo.isValid();
		boolean pre = prenda.isValid();
		boolean preunit = preciounitario.isValid();
		boolean cant = cantidad.isValid();
		boolean stockDisponible = true;
		boolean stockSuficiente = true;
		if(cod && pre && preunit && cant){
			Integer st = Integer.valueOf(stock.getValue().toString());
			if(st == 0){
				stockDisponible = false;
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.separacionNoExistePrenda(), null);
			}else if(cant){
				Integer stCant = Integer.valueOf(cantidad.getValue().toString());
				if(stCant > st){
					stockSuficiente = false;
					MessageBox.alert(constants.sistemaMarcocruzado(), constants.separacionNoStock(), null);
				}
			}
		}
		
		codigo.setAllowBlank(true);
		prenda.setAllowBlank(true);
		preciounitario.setAllowBlank(true);
		cantidad.setAllowBlank(true);
		
		tipo.setAllowBlank(true);
		tela.setAllowBlank(true);
		talla.setAllowBlank(true);
		
		return cod && pre && preunit && cant && stockDisponible && stockSuficiente; 
	}
	
	public boolean validarPrincipal(){
		boolean dr = dni_ruc.isValid();
		boolean fv = fechavencimiento.isValid();
		boolean ac = acuenta.isValid();
		boolean det = true;
		if(store.getCount()==0){
			det = false;
			MessageBox.alert(constants.sistemaMarcocruzado(), constants.separacionDetalleRequerido(), null);
			codigo.focus();
		}
		if(!dr)
			dni_ruc.focus();
		if(!fv)
			fechavencimiento.focus();
		if(!ac)
			acuenta.focus();
		return dr && det && fv && ac;
	}
	
	public void clearDetalle(){
		  		  
		codigo.clear();
		prenda.clear();
		preciounitario.clear();
		cantidad.clear();
		stock.clear();
		
		tela.clear();
		talla.clear();
		color.clear();
		  
	 }
	public void clearPrincipal(){
		  
		dni_ruc.clear();
		dni_ruc.focus();
		nombres.clear();
		acuenta.clear();
		fechavencimiento.setValue(new Date());
		store.removeAll();
		clearDetalle();
		
		List<BeanModel> list = new ArrayList<BeanModel>();
		list.add(documento.getStore().getAt(2));//documento: otro
		documento.setSelection(list);
		
	 }
	
	public void agregarDetalle(){
		if(validarDetalle()){
	    	  
	    	  Boolean add = true;
	    	  if(store.getCount() > 0){
	    		  String mp_id = prenda_id.getValue();
	    		  Double precio_unit = Double.valueOf(preciounitario.getValue().toString());
	    		  Integer cant = Integer.valueOf(cantidad.getValue().toString());
	    		  Integer st = Integer.valueOf(stock.getValue().toString());
	    		  
	    		  Integer mpdetalle_id;
	    		  Integer cantdetalle;
	    		  for(BeanModel b:store.getModels()){
	    			  mpdetalle_id = b.get("modeloprenda_id");
	    			  
	    			  if(mpdetalle_id.toString().equals(mp_id)){
	    				  add = false;	    				
	    				  cantdetalle = b.get("cantidad");
	    				  if(cantdetalle+cant <= st){
		    				  store.getRecord(b).set("preciounitario", precio_unit);
		    				  store.getRecord(b).set("cantidad", cantdetalle+cant);
		    				  store.getRecord(b).set("subtotal",precio_unit*(cantdetalle+cant));
		    				  store.commitChanges();
		    				  clearDetalle();
		    				  codigo.focus();
	    				  }else{
	    					  MessageBox.alert(constants.sistemaMarcocruzado(), constants.separacionNoStock(), null);
	    				  }
	    				  break;
	    			  }
	    		  }
		
	    	  }
	    	  if(add){
		    	  DetalleSeparacion dv = new DetalleSeparacion();
		    	  dv.setModeloprenda_id(Integer.valueOf(prenda_id.getValue()));
		    	  dv.setModeloprenda(prenda.getRawValue());
		    	  dv.setCodigo(codigo.getValue());
		    	  Double precio = Double.valueOf(preciounitario.getValue().toString());
		    	  Integer cant = Integer.valueOf(cantidad.getValue().toString());
		    	  Double monto = precio * cant;
		    	  dv.setPreciounitario(precio);
		    	  dv.setCantidad(cant);
		    	  dv.setSubtotal(monto);
		    	  
		    	  dv.setTipoprenda((String)tipo.getValue().get("nombre"));	    			  
    			  dv.setTela((String)tela.getValue().get("descripcion"));
    			  dv.setTalla((String)talla.getValue().get("descripcion"));	    			  
    			  if(color.getValue() != null)
    				  dv.setColor((String)color.getValue().get("descripcion"));
		    	  
		    	  BeanModelFactory beanModelFactory =  BeanModelLookup.get().getFactory(dv.getClass());
		    	  store.add(beanModelFactory.createModel(dv));
		    	  clearDetalle();
		    	  codigo.focus();
	    	  }		    	  
  	  }
	}
	
}
